home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games: Greatest Hits 1996 / Amiga Games: Greatest Hits 1996.iso / spiele / publicdomain / ls-tron3.1 / init.i < prev    next >
Text File  |  1996-04-30  |  34KB  |  1,035 lines
  1. { Init.i }
  2.  
  3. {$I "Extra.i"   }
  4.  
  5. PROCEDURE Init; { Alles zurücksetzen }
  6.  
  7.   PROCEDURE Info;
  8.  
  9.     CONST sNewWindow : NewWindow = (0,10,640,246,0,0,RawKey_F+
  10.                                     MouseButtons_F,SMART_Refresh+
  11.                                     ACTIVATE+RMBTrap+Borderless,NIL,
  12.                                     NIL,NIL,NIL,NIL,640,246,640,246,
  13.                                     CUSTOMSCREEN_F);
  14.  
  15.     VAR sWindow   : WindowPtr;
  16.         sRastPort : RastPortPtr;
  17.  
  18.     PROCEDURE ClearPage;   { Fensterinhalt löschen }
  19.  
  20.       BEGIN
  21.         SetAPen(sRastPort,0);
  22.         RectFill(sRastPort,4,4,635,241);
  23.       END;
  24.  
  25.     PROCEDURE WaitClick; { Auf MSG warten }
  26.  
  27.       VAR sMsg : IntuiMessagePtr;
  28.  
  29.       BEGIN
  30.         sMsg:=NIL;
  31.         sMsg:=ADDRESS(GetMsg(sWindow^.UserPort));
  32.         WHILE sMsg<>NIL DO
  33.           BEGIN
  34.             ReplyMsg(ADDRESS(sMsg));
  35.             sMsg:=NIL;
  36.             sMsg:=ADDRESS(GetMsg(sWindow^.UserPort));
  37.           END;
  38.  
  39.         REPEAT
  40.           sMSG:=NIL;
  41.           sMSG:=ADDRESS(WaitPort(sWindow^.UserPort));
  42.           sMSG:=ADDRESS(GetMSG(  sWindow^.UserPort));
  43.         UNTIL sMSG<>NIL;
  44.         ReplyMSG(ADDRESS(sMSG));
  45.       END;
  46.  
  47.     PROCEDURE Page1; { Erste Infoseite zeigen }
  48.  
  49.       BEGIN
  50.  
  51.         Print(sRastPort,197, 20,"L     SSSSS       TTTTT RRRRR  OOO  N   N",8);
  52.         Print(sRastPort,197, 28,"L     S             T   R   R O   O NN  N",8);
  53.         Print(sRastPort,197, 36,"L     SSSSS -----   T   RRRRR O   O N N N",8);
  54.         Print(sRastPort,197, 44,"L         S         T   R  R  O   O N  NN",8);
  55.         Print(sRastPort,197, 52,"LLLLL SSSSS         T   R   R  OOO  N   N",8);
  56.  
  57.         Print(sRastPort,293, 68,"Version 3",8);
  58.  
  59.         IF Sprache=Deutsch THEN Print(sRastPort,150,120,"Programm:",8)
  60.                            ELSE Print(sRastPort,150,120,"Program:" ,8);
  61.         Print(sRastPort,160,136,"Dennis Müller",8);
  62.  
  63.         IF Sprache=Deutsch THEN
  64.            Print(sRastPort,150,170,"Dankeschöns gehen an:",8)
  65.           ELSE
  66.            Print(sRastPort,150,170,"Thanx 2:"             ,8);
  67.  
  68.         Print(sRastPort,160,186,"Andreas 'Wurzelsepp' Neumann",8);
  69.         Print(sRastPort,160,194,"'Diesel' Bernd Künnen"       ,8);
  70.         Print(sRastPort,160,202,"Maximilian von Fürstenberg"  ,8);
  71.         Print(sRastPort,160,210,"Jens Meyer"                  ,8);
  72.         Print(sRastPort,160,218,"Thomas Müller"               ,8);
  73.       END;
  74.  
  75.     BEGIN
  76.       sNewWindow.screen:=MyScreen; { Fenster öffnen }
  77.       sWindow:=NIL;
  78.       sWindow:=OpenWindow(ADR(sNewWindow));
  79.       IF sWindow=NIL THEN CleanExit(Error_No_Window);
  80.  
  81.       ViewMouse(sWindow);          { Mauszeiger einstellen }
  82.       sRastPort:=sWindow^.RPort;
  83.  
  84.       SetAPen(sRastPort,1);
  85.       Line(sRastPort,0,0,639,0);
  86.       DrawIBox(sRastPort,0,1,639,245);
  87.       DrawIBox(sRastPort,1,1,638,245);
  88.       Draw0Box(sRastPort,2,2,637,244);
  89.       Draw0Box(sRastPort,3,3,636,243);
  90.  
  91.       Page1;
  92.       WaitClick;
  93.  
  94.       ClearPointer(SWindow);
  95.       MyCloseWindow(sWindow);          { Und Ende }
  96.       ActivateWindow(myWindow);
  97.     END;
  98.  
  99.   PROCEDURE SetLoadedPlayers;
  100.  
  101.     VAR shorthelp : BYTE;
  102.  
  103.     BEGIN
  104.       WITH TBase^.MyMaze DO
  105.         FOR ShortHelp:=1 TO Maxplay DO
  106.           IF players[shorthelp].ist_geladen THEN
  107.              BEGIN
  108.                TBase^.players[shorthelp].x :=players[shorthelp].pos.x;
  109.                TBase^.players[shorthelp].y :=players[shorthelp].pos.y;
  110.                TBase^.players[shorthelp].mx:=players[shorthelp].bewegung.x;
  111.                TBase^.players[shorthelp].my:=players[shorthelp].bewegung.y;
  112.              END;
  113.     END;
  114.  
  115.   PROCEDURE Init_Base; { Tronbase einstellen }
  116.  
  117.     VAR ShortHelp : BYTE;
  118.  
  119.     BEGIN
  120.       WITH TBase^ DO
  121.         BEGIN
  122.           QuitGame:=FALSE;  { Spiel erstmal nicht beenden               }
  123.  
  124.           remain:=player;   { Folgen des letzten Spiels beseitigen und  }
  125.                             { Optionen beachten.                        }
  126.  
  127.           first:=0;
  128.           secnd:=0;         { Sieger erstmal löschen => Gleichberechtigung }
  129.           third:=0;
  130.  
  131.           FOR Shorthelp:=1 TO Maxplay DO      { Alle Spieler durchgehen }
  132.               BEGIN
  133.                 WITH players[shorthelp] DO
  134.                   BEGIN
  135.                     destroyed:=FALSE;         { Ohne Spiel keiner zerstört }
  136.                     lastleft:=FALSE;          { etc.                       }
  137.                     lastright:=FALSE;
  138.  
  139.                     FOR pos:=1 TO max_Length DO { Werte für Spurverfolgung }
  140.                       WITH strich[pos] DO       { zurückstellen            }
  141.                         BEGIN
  142.                           x:=0;
  143.                           y:=0;
  144.                         END;
  145.                     pos:=1;                     {}
  146.                     ok:=(shorthelp<=Player);    { Spieler, die mitspielen, }
  147.                                                 { sind in Ordnung          }
  148.                     complayer:=(Shorthelp>human);{Eventuell Computerspieler}
  149.  
  150.                     hits:=0;                     { Treffer löschen         }
  151.                     left:=RangeRandom(1);        { Nur für Computerspieler }
  152.                     Turbo:=(RangeRandom(5)=0);   {          "              }
  153.                     KI:=RangeRandom(3);          {          "              }
  154.                     Ausweicher:=RangeRandom(5)>0;{          "              }
  155.                     ID:=ShortHelp;               { Spieler Identifier      }
  156.                   END;
  157.               END;
  158.  
  159.           FOR Shorthelp:=1 TO (maxPlay DIV 2) DO { 2. Durchlauf }
  160.               BEGIN
  161.                 WITH Players[2*ShortHelp-1] DO
  162.                   BEGIN
  163.                     x:=101+shorthelp;            { Startposition festlegen }
  164.                     y:=shortHelp*15+94;
  165.                     mx:=1;                       { Startrichtung einstellen}
  166.                     my:=0;
  167.                   END;
  168.  
  169.                 WITH Players[2*ShortHelp] DO     { Und die restlichen Spieler }
  170.                   BEGIN
  171.                     x:=201+shorthelp;            { Starten weiter rechts }
  172.                     y:=shortHelp*15+95;
  173.                     mx:=-1;                      { und in die andere Richtung}
  174.                     my:=0;
  175.                   END;
  176.               END;
  177.         END;
  178.     END;
  179.  
  180.   FUNCTION ReactMSG(MyMSG : IntuiMessagePtr) : BOOLEAN;
  181.  
  182.     { Immernoch der User }
  183.  
  184.     PROCEDURE Neu; { Highscoreliste löschen }
  185.  
  186.       VAR help : BYTE;
  187.  
  188.       BEGIN
  189.         FOR help:=1 TO maxplay DO TBase^.players[help].score:=0;
  190.       END;
  191.  
  192.     PROCEDURE Options; { Optionenmenü }
  193.  
  194.       CONST aNewWindow : NewWindow = (0,10,640,246,0,0,RawKey_F+Gadgetup_f+
  195.                                       GadgetDown_F,SMART_Refresh+ACTIVATE+
  196.                                       RMBTrap+Borderless,NIL,NIL,NIL,NIL,
  197.                                       NIL,640,246,640,246,CUSTOMSCREEN_F);
  198.  
  199.             OptGad01    : Gadget    = (NIL,180, 18,151, 11,GadghImage,
  200.                                        RelVerify,BOOLGADGET,NIL,NIL,NIL,
  201.                                        0,NIL, 1,NIL);
  202.             OptGad02    : Gadget    = (NIL,180, 43,151, 11,GadghImage,
  203.                                        RelVerify,BOOLGADGET,NIL,NIL,NIL,
  204.                                        0,NIL, 2,NIL);
  205.             OptGad03    : Gadget    = (NIL,180, 68,151, 11,GadghImage,
  206.                                        RelVerify,BOOLGADGET,NIL,NIL,NIL,
  207.                                        0,NIL, 3,NIL);
  208.             OptGad04    : Gadget    = (NIL,180, 93,151, 11,GadghImage,
  209.                                        RelVerify,BOOLGADGET,NIL,NIL,NIL,
  210.                                        0,NIL, 4,NIL);
  211.             OptGad05    : Gadget    = (NIL,180,118,151, 11,GadghImage,
  212.                                        RelVerify,BOOLGADGET,NIL,NIL,NIL,
  213.                                        0,NIL, 5,NIL);
  214.             OptGad06    : Gadget    = (NIL,180,143,151, 11,GadghImage,
  215.                                        RelVerify,BOOLGADGET,NIL,NIL,NIL,
  216.                                        0,NIL, 6,NIL);
  217.             OptGad07    : Gadget    = (NIL,180,168,151, 11,GadghImage,
  218.                                        RelVerify,BOOLGADGET,NIL,NIL,NIL,
  219.                                        0,NIL, 7,NIL);
  220.             OptGad10    : Gadget    = (NIL,180,198,151, 11,GadghImage,
  221.                                        RelVerify,BOOLGADGET,NIL,NIL,NIL,
  222.                                        0,NIL,10,NIL);
  223.  
  224.             OptKoord1   : Koord     = ( 0,11,  0, 0,151, 0);
  225.             OptKoord2   : Koord     = ( 0,11,151,11,151, 0);
  226.             OptKoord3   : Koord     = ( 0,11,  0, 0,151, 0);
  227.             OptKoord4   : Koord     = ( 0,11,151,11,151, 0);
  228.  
  229.             OptBora2    : Border    = (0,0,1,8,5,3,NIL,NIL);
  230.             OptBora1    : Border    = (0,0,8,1,5,3,NIL,NIL);
  231.             OptBorb2    : Border    = (0,0,8,1,5,3,NIL,NIL);
  232.             OptBorb1    : Border    = (0,0,1,8,5,3,NIL,NIL);
  233.  
  234.       VAR aWindow    : WindowPtr;        { Systemkram... }
  235.           aRastPort  : RastPortPtr;
  236.           aIntMSG    : IntuiMessagePtr;
  237.           MyEnd      : BOOLEAN;          { Ende???       }
  238.           old_human,
  239.           old_Level,
  240.           old_speed,
  241.           old_player,
  242.           old_length : SHORT;            { Für Überprüfung von Änderungen }
  243.           MyString   : STRING;           { Für diverses... }
  244.  
  245.       PROCEDURE KillBox(PosX,PosY : SHORT); { Box vom Bildschirm löschen }
  246.  
  247.         CONST x0    = 376;
  248.               y0    =  19;
  249.               seite =   8;
  250.  
  251.         VAR MyX,MyY : SHORT;
  252.  
  253.         BEGIN
  254.           CASE PosY OF
  255.             1 : MyY:=y0+  0;
  256.             2 : MyY:=y0+ 25;
  257.             3 : MyY:=y0+ 50;
  258.             4 : MyY:=y0+ 75;
  259.             5 : MyY:=y0+100;
  260.             6 : MyY:=y0+125;
  261.             7 : MyY:=y0+150;
  262.           END;
  263.  
  264.           myX:=x0+2*Seite*(PosX-1);
  265.  
  266.           SetAPen(aRastPort,0);
  267.           RectFill(aRastport,MyX,MyY,MyX+2*seite-1,MyY+Seite-1);
  268.         END;
  269.  
  270.       PROCEDURE NormalBox(x,y : SHORT); { Kasten malen }
  271.  
  272.         CONST x0    = 376;
  273.               y0    =  19;
  274.               seite =   8;
  275.  
  276.         VAR MyX,MyY : SHORT;
  277.  
  278.         BEGIN
  279.           CASE y OF
  280.             1 : MyY:=y0+  0;
  281.             2 : MyY:=y0+ 25;
  282.             3 : MyY:=y0+ 50;
  283.             4 : MyY:=y0+ 75;
  284.             5 : MyY:=y0+100;
  285.             6 : MyY:=y0+125;
  286.             7 : MyY:=y0+150;
  287.           END;
  288.  
  289.           myX:=x0+2*Seite*(x-1);
  290.  
  291.           SetAPen(aRastPort,schwarz);
  292.           Line(aRastPort,MyX          ,MyY+seite-1,
  293.                          MyX+2*seite-1,MyY+seite-1);
  294.           Draw(aRastPort,MyX+2*seite-1,MyY        );
  295.           Line(aRastPort,MyX+2*seite-2,MyY+seite-1,
  296.                          MyX+2*seite-2,MyY        );
  297.  
  298.           SetAPen(aRastPort,mgrau);
  299.           Line(aRastPort,MyX          ,MyY+seite-1,
  300.                          MyX          ,MyY        );
  301.           Draw(aRastPort,MyX+2*seite-2,MyY        );
  302.           Line(aRastPort,MyX        +1,MyY+seite-2,
  303.                          MyX        +1,MyY        );
  304.         END;
  305.  
  306.       PROCEDURE EmptyBox(x,y : SHORT); { Leeren Kasten malen }
  307.  
  308.         CONST x0    = 376;
  309.               y0    =  19;
  310.               seite =   8;
  311.  
  312.         VAR MyX,MyY : SHORT;
  313.  
  314.         BEGIN
  315.           NormalBox(x,y);
  316.  
  317.           CASE y OF
  318.             1 : MyY:=y0+  0;
  319.             2 : MyY:=y0+ 25;
  320.             3 : MyY:=y0+ 50;
  321.             4 : MyY:=y0+ 75;
  322.             5 : MyY:=y0+100;
  323.             6 : MyY:=y0+125;
  324.             7 : MyY:=y0+150;
  325.           END;
  326.  
  327.           myX:=x0+2*Seite*(x-1);
  328.  
  329.           SetAPen(aRastPort,0);
  330.           RectFill(aRastport,MyX+2,MyY+1,MyX+2*seite-3,MyY+Seite-2);
  331.         END;
  332.  
  333.       PROCEDURE FullBox(x,y : SHORT); { Blauen Kasten malen }
  334.  
  335.         CONST x0    = 376;
  336.               y0    =  19;
  337.               seite =   8;
  338.  
  339.         VAR MyX,MyY : SHORT;
  340.  
  341.         BEGIN
  342.           NormalBox(x,y);
  343.  
  344.           CASE y OF
  345.             1 : MyY:=y0+  0;
  346.             2 : MyY:=y0+ 25;
  347.             3 : MyY:=y0+ 50;
  348.             4 : MyY:=y0+ 75;
  349.             5 : MyY:=y0+100;
  350.             6 : MyY:=y0+125;
  351.             7 : MyY:=y0+150;
  352.           END;
  353.  
  354.           myX:=x0+2*Seite*(x-1);
  355.  
  356.           SetAPen(aRastPort,5);
  357.           RectFill(aRastport,MyX+2,MyY+1,MyX+2*seite-3,MyY+Seite-2);
  358.         END;
  359.  
  360.       PROCEDURE WriteLevel;              { Level ausgeben }
  361.  
  362.         VAR x : SHORT;
  363.  
  364.         BEGIN
  365.           FOR x:=0 TO TBase^.Level DO
  366.             FullBox(x+1,1);
  367.  
  368.           FOR x:=Tbase^.Level+1 TO suicide DO
  369.             EmptyBox(x+1,1);
  370.         END;
  371.  
  372.       PROCEDURE WriteSpeed;              { Geschwindigkeit ausgeben }
  373.  
  374.         VAR x : SHORT;
  375.  
  376.         BEGIN
  377.           FOR x:=0 TO TBase^.speed DO
  378.             FullBox(x+1,2);
  379.  
  380.           FOR x:=Tbase^.speed+1 TO Turbo DO
  381.             EmptyBox(x+1,2);
  382.         END;
  383.  
  384.       PROCEDURE WritePlayer;             { Spieleranzahl ausgeben }
  385.  
  386.         VAR x : SHORT;
  387.  
  388.         BEGIN
  389.           FOR x:=1 TO TBase^.player DO
  390.             FullBox(x,3);
  391.  
  392.           FOR x:=Tbase^.player+1 TO Maxplay DO
  393.             EmptyBox(x,3);
  394.         END;
  395.  
  396.       PROCEDURE WriteHuman;              { Anzahl der menschlichen S. ausg.}
  397.  
  398.         VAR x : SHORT;
  399.  
  400.         BEGIN
  401.           FOR x:=1 TO TBase^.human DO
  402.             FullBox(x,4);
  403.  
  404.           FOR x:=Tbase^.human+1 TO maxplay DO
  405.             EmptyBox(x,4);
  406.         END;
  407.  
  408.       PROCEDURE WriteColour;             { Hintergrundfarbe ändern }
  409.  
  410.         BEGIN
  411.           WITH TBase^ DO
  412.             BEGIN
  413.               SetRGB4(ADR(MyScreen^.SViewPort),9,
  414.                       BackColours[BackColour].r,
  415.                       BackColours[BackColour].g,
  416.                       BackColours[BackColour].b);
  417.             END;
  418.         END;
  419.  
  420.       PROCEDURE WriteLength;             { Strichlänge ausgeben }
  421.  
  422.         VAR x : SHORT;
  423.  
  424.         BEGIN
  425.           IF TBase^.Max_Length>0 THEN
  426.              BEGIN
  427.                FOR x:=1 TO TBase^.Max_Length DIV 50 DO
  428.                  FullBox(x,6);
  429.  
  430.                FOR x:=(TBase^.Max_Length DIV 50)+1 TO 10 DO
  431.                  EmptyBox(x,6);
  432.              END
  433.             ELSE
  434.              BEGIN
  435.                FOR x:=1 TO 10 DO
  436.                  Killbox(x,6);
  437.                IF Sprache=Deutsch THEN Print(aRastPort,377,151,"Aus",1)
  438.                                   ELSE Print(aRastPort,377,151,"Off",1);
  439.              END;
  440.         END;
  441.  
  442.       PROCEDURE WriteLanguage;
  443.  
  444.         BEGIN
  445.           SetAPen(aRastPort,0);
  446.           RectFill(aRastPort,370,170,470,177);
  447.           IF Sprache=Deutsch THEN Print(aRastPort,376,176,"Deutsch",1)
  448.                              ELSE Print(aRastPort,376,176,"English",1);
  449.         END;
  450.  
  451.       PROCEDURE Draw_Menu;
  452.  
  453.         BEGIN
  454.           IF Sprache=Deutsch THEN
  455.              BEGIN
  456.                Print(aRastPort,241, 26,     "Level"     ,1);{ Optionenmenü }
  457.                Print(aRastPort,211, 51,"Geschwindigkeit",1);{ vorbereiten  }
  458.                Print(aRastPort,235, 76,    "Spieler"    ,1);
  459.                Print(aRastPort,226,101,   "Mitspieler"  ,1);
  460.                Print(aRastPort,235,126,    " Farbe "    ,1);
  461.                Print(aRastPort,214,151,"Spurverfolgung" ,1);
  462.                Print(aRastPort,229,176,    " Sprache "  ,1);
  463.                Print(aRastPort,244,206,      "Ende"     ,8);
  464.              END
  465.             ELSE
  466.              BEGIN
  467.                Print(aRastPort,241, 26,     "Level"     ,1);
  468.                Print(aRastPort,211, 51,"     Speed     ",1);
  469.                Print(aRastPort,235, 76,    "Players"    ,1);
  470.                Print(aRastPort,223,101,  "   Human   "  ,1);
  471.                Print(aRastPort,238,126,    "Colour"     ,1);
  472.                Print(aRastPort,214,151," Tracktracing " ,1);
  473.                Print(aRastPort,232,176,    "Language"   ,1);
  474.                Print(aRastPort,244,206,     "Quit"      ,8);
  475.              END;
  476.  
  477.           WriteLevel;                      { Optionen ausgeben }
  478.           WriteSpeed;
  479.           WritePlayer;
  480.           WriteHuman;
  481.  
  482.           SetAPen(aRastPort,9);
  483.           RectFill(aRastPort,376,118,535,128);
  484.  
  485.           WriteColour;
  486.           WriteLength;
  487.           WriteLanguage;
  488.         END;
  489.  
  490.       FUNCTION CalcMSG(sMSG : IntuiMessagePtr) : BOOLEAN;
  491.  
  492.         {und noch mal User}
  493.  
  494.         VAR myHelp : SHORT;
  495.             MyKey  : SHORT;
  496.  
  497.         BEGIN
  498.           IF (sMSG^.Class=RawKey_F    ) OR
  499.              (sMSG^.Class=GadgetUp_F  ) OR
  500.              (sMSG^.Class=GadgetDown_F) THEN
  501.              BEGIN
  502.                IF sMSG^.Class=RawKey_F THEN
  503.                   BEGIN
  504.                     MyKey:=sMSG^.Code;
  505.  
  506.                     CASE MyKey OF
  507.                       F1 : SelectGadget(aRastPort,ADR(OptGad01));
  508.                       F2 : SelectGadget(aRastPort,ADR(OptGad02));
  509.                       F3 : SelectGadget(aRastPort,ADR(OptGad03));
  510.                       F4 : SelectGadget(aRastPort,ADR(OptGad04));
  511.                       F5 : SelectGadget(aRastPort,ADR(OptGad05));
  512.                       F6 : SelectGadget(aRastPort,ADR(OptGad06));
  513.                       F7 : SelectGadget(aRastPort,ADR(OptGad07));
  514.                       F10: SelectGadget(aRastPort,ADR(OptGad10));
  515.                      ELSE;
  516.                     END;
  517.                   END
  518.                  ELSE MyKey:=F1+GetGadgetID(sMsg^.IAddress)-1;
  519.                         { Gadgetnummern in Tastaturcodes umwandeln }
  520.  
  521.                CASE MyKey OF
  522.                 $50 : BEGIN { F1 gedrückt? - Level erhöhen }
  523.                         TBase^.Level:=(TBase^.Level+1) MOD 6;
  524.                         WriteLevel;
  525.                         CalcMSG:=FALSE;
  526.                       END;
  527.                 $51 : BEGIN { F2 gedrückt? - Geschwindigkeit erhöhen }
  528.                         TBase^.Speed:=(TBase^.Speed+1) MOD 6;
  529.                         WriteSpeed;
  530.                         CalcMSG:=FALSE;
  531.                       END;
  532.                 $52 : BEGIN { F3 gedrückt - Anzahl der Spieler erhöhen }
  533.                         TBase^.player:=TBase^.player+1;
  534.                         IF TBase^.player>maxplay THEN TBase^.player:=TBase^.human;
  535.                         IF TBase^.player<2 THEN TBase^.player:=2;
  536.                         TBase^.remain:=TBase^.player;
  537.                         FOR MyHelp:=1 TO maxplay DO
  538.                             TBase^.players[myHelp].ok:=(MyHelp<=TBase^.player);
  539.  
  540.                         WritePlayer;
  541.  
  542.                         CalcMSG:=FALSE;
  543.                       END;
  544.                 $53 : BEGIN { F4 - Anzahl der (über-)menschlichen Spieler }
  545.                         TBase^.human:=TBase^.human+1;
  546.                         IF TBase^.human>TBase^.player THEN TBase^.human:=0;
  547.                         FOR MyHelp:=1 TO maxplay DO
  548.                           TBase^.players[myhelp].complayer:=(MyHelp>TBase^.Human);
  549.  
  550.                         WriteHuman;
  551.  
  552.                         CalcMSG:=FALSE;
  553.                       END;
  554.                 $54 : BEGIN { F5 - Farben verändern }
  555.                         WITH TBase^ DO
  556.                           BEGIN
  557.                             backColour:=(Backcolour MOD 4)+1;
  558.  
  559.                             WriteColour;
  560.                           END;
  561.                         CalcMSG:=FALSE;
  562.                       END;
  563.                 $55 : BEGIN { F6 - Strichlänge verändern }
  564.                         TBase^.max_Length:=TBase^.max_Length+50;
  565.                         IF TBase^.max_Length>maximum THEN TBase^.max_Length:=0;
  566.  
  567.                         WriteLength;
  568.  
  569.                         CalcMSG:=FALSE;
  570.                       END;
  571.                 $56 : BEGIN
  572.                         IF Sprache=Deutsch THEN TBase^.Sprache:=CHR(69)
  573.                                            ELSE TBase^.Sprache:=CHR(68);
  574.                         Draw_Menu;
  575.                         Sprache_Hauptmenue;
  576.  
  577.                         CalcMSG:=FALSE;
  578.                       END;
  579.                 $59 : CalcMSG:=TRUE; { F10 und raus }
  580.                 ELSE CalcMSG:=FALSE;
  581.                END; { Ende von Case }
  582.              END;
  583.         END; { Ende der Prozedur }
  584.  
  585.       PROCEDURE OpenOptionsDisplay;
  586.  
  587.         BEGIN
  588.           OptBora2.xy:=ADR(OptKoord2);
  589.           OptBora1.xy:=ADR(OptKoord1);
  590.           OptBora1.NextBorder:=ADR(OptBora2);
  591.  
  592.           OptBorb2.xy:=ADR(OptKoord4);
  593.           OptBorb1.xy:=ADR(OptKoord3);
  594.           OptBorb1.NextBorder:=ADR(OptBorb2);
  595.  
  596.           SetGadget(ADR(OptGad10),NIL          ,ADR(OptBora1),ADR(OptBorb1),NIL);
  597.           SetGadget(ADR(OptGad07),ADR(OptGad10),ADR(OptBora1),ADR(OptBorb1),NIL);
  598.           SetGadget(ADR(OptGad06),ADR(OptGad07),ADR(OptBora1),ADR(OptBorb1),NIL);
  599.           SetGadget(ADR(OptGad05),ADR(OptGad06),ADR(OptBora1),ADR(OptBorb1),NIL);
  600.           SetGadget(ADR(OptGad04),ADR(OptGad05),ADR(OptBora1),ADR(OptBorb1),NIL);
  601.           SetGadget(ADR(OptGad03),ADR(OptGad04),ADR(OptBora1),ADR(OptBorb1),NIL);
  602.           SetGadget(ADR(OptGad02),ADR(OptGad03),ADR(OptBora1),ADR(OptBorb1),NIL);
  603.           SetGadget(ADR(OptGad01),ADR(OptGad02),ADR(OptBora1),ADR(OptBorb1),NIL);
  604.  
  605.           aNewWindow.firstGadget:=ADR(OptGad01);
  606.           aNewWindow.screen:=MyScreen;     { Fenster öffnen }
  607.           aWindow:=NIL;
  608.           aWindow:=OpenWindow(ADR(ANewWindow));
  609.           IF aWindow=NIL THEN CleanExit(Error_No_Window);
  610.           aRastPort:=aWindow^.RPort;
  611.  
  612.           ViewMouse(aWindow);               { Mauszeiger einstellen }
  613.  
  614.           SetAPen(aRastPort,1);
  615.           Line(aRastPort,0,0,639,0);
  616.           DrawIBox(aRastPort,0,1,639,245);
  617.           DrawIBox(aRastPort,1,1,638,245);
  618.           Draw0Box(aRastPort,2,2,637,244);
  619.           Draw0Box(aRastPort,3,3,636,243);
  620.         END;
  621.  
  622.       BEGIN { Öffnen }
  623.         myString:=AllocString(255);
  624.  
  625.         old_human :=TBase^.human;        { Alte Einstellungen merken }
  626.         old_player:=TBase^.player;
  627.         old_Level :=TBase^.level;
  628.         old_Speed :=TBase^.Speed;
  629.         old_Length:=TBase^.Max_Length;
  630.  
  631.         OpenOptionsDisplay;
  632.         Draw_Menu;
  633.  
  634.         REPEAT
  635.           aIntMSG:=NIL; { User will was ? }
  636.           aIntMSG:=ADDRESS(WaitPort(aWindow^.UserPort));
  637.           aIntMSG:=ADDRESS(GetMSG(aWindow^.USERPort));
  638.           IF aIntMSG<>NIL THEN BEGIN
  639.                                  MyEnd:=CalcMSG(aIntMSG); { MSG bearbeiten }
  640.                                  ReplyMSG(ADDRESS(aIntMSG));
  641.                                END;
  642.         UNTIL MyEnd;
  643.  
  644.         REPEAT
  645.           aIntMSG:=NIL; { User will noch was ? Zu spät. }
  646.           aIntMSG:=ADDRESS(GetMSG(aWindow^.USERPort));
  647.           IF aIntMSG<>NIL THEN BEGIN
  648.                                  ReplyMSG(ADDRESS(aIntMSG));
  649.                                END;
  650.         UNTIL aIntMSG=NIL;
  651.  
  652.         IF NOT ((old_human =TBase^.human     )  AND
  653.                 (old_player=TBase^.player    )  AND
  654.                 (old_Level =TBase^.level     )  AND
  655.                 (old_Speed =TBase^.Speed     )  AND
  656.                 (old_Length=TBase^.Max_Length)) THEN Neu; { Wenn etwas     }
  657.                                                           { geändert wurde,}
  658.                                                           { Highscore      }
  659.                                                           { löschen.       }
  660.  
  661.         ClearPointer(AWindow);
  662.         MyCloseWindow(aWindow); { Fenster schließen und umschalten }
  663.         ActivateWindow(MyWindow);
  664.  
  665.         FreeString(MyString);
  666.       END;
  667.  
  668.     PROCEDURE HighScore; { highscoreliste zeigen }
  669.  
  670.       CONST HighGad    : Gadget    = (NIL,267,190,101,11,GadghImage,
  671.                                       RelVerify,BOOLGADGET,NIL,NIL,NIL,
  672.                                       0,NIL, 1,NIL);
  673.             OkGad      : Gadget    = (NIL,267,210,101,11,GadghImage,
  674.                                       RelVerify,BOOLGADGET,NIL,NIL,NIL,
  675.                                       0,NIL,10,NIL);
  676.  
  677.             HighInt    : IntuiText = (1,0,0,41,1,NIL,"Neu",NIL);
  678.             eHighInt   : IntuiText = (1,0,0,41,1,NIL,"New",NIL);
  679.             OkInt      : IntuiText = (8,0,0,44,1,NIL,"Ok" ,NIL);
  680.  
  681.             sNewWindow : NewWindow = (0,10,640,246,0,0,MouseButtons_f+
  682.                                       GadgetDown_f+GadgetUp_f+RawKey_F,
  683.                                       SMART_Refresh+ACTIVATE+RMBTrap+
  684.                                       Borderless,NIL,NIL,NIL,NIL,NIL,
  685.                                       640,246,640,246,CUSTOMSCREEN_F);
  686.  
  687.       VAR sWindow   : WindowPtr;
  688.           sRastPort : RastPortPtr;
  689.           sMSG      : IntuiMessagePtr;
  690.  
  691.       PROCEDURE Draw_Highscore;
  692.  
  693.         TYPE mitspieler = RECORD
  694.                             punkte,
  695.                             nummer : SHORT;
  696.                           END;
  697.              Table      = ARRAY[1..6] OF mitSpieler;
  698.  
  699.         PROCEDURE SortScores(VAR myTable : Table);
  700.  
  701.           PROCEDURE Vertausche(y : SHORT); { Liste sortieren }
  702.  
  703.             VAR variable : mitSpieler;
  704.  
  705.             BEGIN
  706.               variable    :=myTable[y];
  707.               mytable[y]  :=mytable[y+1];
  708.               mytable[y+1]:=variable;
  709.             END;
  710.  
  711.           VAR sortiere : BOOLEAN;
  712.               x        : SHORT;
  713.  
  714.           BEGIN
  715.             sortiere:=TRUE;
  716.             WHILE sortiere DO { Solange sortieren bis nicht mehr sortiert wird}
  717.               BEGIN
  718.                 sortiere:=FALSE;
  719.                 FOR x:=1 TO maxplay-1 DO
  720.                   IF mytable[x].punkte<mytable[x+1].punkte THEN
  721.                      BEGIN
  722.                        Vertausche(x);
  723.                        sortiere:=TRUE;
  724.                      END;
  725.               END;
  726.           END;
  727.  
  728.         VAR highscore : Table;
  729.             help      : SHORT;
  730.             myString  : STRING;
  731.             abstand   : BYTE;
  732.  
  733.         BEGIN
  734.           FOR help:=1 TO maxplay DO    { Wichtige Daten ermitteln }
  735.             BEGIN
  736.               WITH HighScore[help] DO
  737.                 BEGIN
  738.                   nummer:=help;
  739.                   punkte:=TBase^.players[help].score;
  740.                 END;
  741.             END;
  742.  
  743.           SortScores(HighScore);      { Sortieren }
  744.  
  745.           SetAPen(sRastPort,0);
  746.           RectFill(sRastPort,180,40,630,180);
  747.  
  748.           abstand:=10*(maxplay-TBase^.player)+46; { Abstand vom oberen Rand }
  749.  
  750.           myString:=AllocString(20);
  751.  
  752.           FOR help:=1 TO TBase^.player DO   { Ausgeben }
  753.             BEGIN
  754.               WITH highscore[help] DO
  755.                 BEGIN
  756.                   makeString(help,MyString);
  757.                   StrCat(myString,".");
  758.                   Print(sRastPort,188,abstand+20*help,mystring,nummer+1);
  759.  
  760.                   Print(sRastPort,212,abstand+20*help,TBase^.players[nummer].name,nummer+1);
  761.  
  762.                   Makestring(punkte,myString);
  763.                   Print(sRastPort,418-LENGTH(MyString),abstand+20*help,MyString,nummer+1);
  764.                  END;
  765.             END;
  766.  
  767.           FreeString(myString);
  768.         END;
  769.  
  770.       FUNCTION Reaction(OneMsg : IntuiMessagePtr) : BOOLEAN;
  771.  
  772.         VAR Beende : BOOLEAN;
  773.  
  774.         BEGIN
  775.           Beende:=FALSE;
  776.           IF OneMSG<>NIL THEN
  777.              BEGIN
  778.                IF OneMSG^.Class=GadgetUp_F THEN
  779.                   CASE GetGadgetID(OneMSG^.IAddress) OF
  780.                     1 : BEGIN
  781.                           Neu;
  782.                           Draw_Highscore;
  783.                         END;
  784.                    10 : Beende:=TRUE;
  785.                   END;
  786.  
  787.                IF (OneMSG^.Class=Rawkey_F) THEN
  788.                   CASE OneMSG^.Code OF
  789.                     F1 : BEGIN
  790.                            Neu;
  791.                            Draw_Highscore;
  792.                          END;
  793.                    F10 : Beende:=TRUE;
  794.                    ELSE;
  795.                   END;
  796.  
  797.                ReplyMSG(ADDRESS(OneMsg));
  798.              END;
  799.  
  800.           Reaction:=Beende;
  801.         END;
  802.  
  803.       BEGIN
  804.         SNewWindow.Screen:=MyScreen;
  805.  
  806.         SetGadget(ADR(OkGad),NIL,ADR(Bora1),ADR(Borb1),ADR(OkInt));
  807.         IF Sprache=Deutsch THEN
  808.            SetGadget(ADR(HighGad),ADR(OkGad),ADR(Bora1),ADR(Borb1),ADR( highInt))
  809.           ELSE
  810.            SetGadget(ADR(HighGad),ADR(OkGad),ADR(Bora1),ADR(Borb1),ADR(ehighInt));
  811.  
  812.         SNewWindow.firstgadget:=ADR(HighGad);
  813.  
  814.         sWindow:=NIL;
  815.         sWindow:=OpenWindow(ADR(sNewWindow));
  816.         IF sWindow=NIL THEN CleanExit(Error_No_Window);
  817.  
  818.         ViewMouse(sWindow);
  819.         sRastPort:=sWindow^.RPort;
  820.  
  821.         SetAPen(sRastPort,1);
  822.         Line(sRastPort,0,0,639,0);
  823.  
  824.         DrawIBox(sRastPort,0,1,639,245);
  825.         DrawIBox(sRastPort,1,1,638,245);
  826.  
  827.         Draw0Box(sRastPort,2,2,637,244);
  828.         Draw0Box(sRastPort,3,3,636,243);
  829.  
  830.         DrawBox(sRastPort,274,18,358,29);
  831.         Print(sRastPort,289,26,"Highscore",1);
  832.  
  833.         Draw_Highscore;
  834.  
  835.         REPEAT
  836.           sMsg:=NIL;
  837.           sMSG:=ADDRESS(WaitPort(sWindow^.UserPort));
  838.           sMSG:=ADDRESS(GetMSG(  sWindow^.UserPort));
  839.         UNTIL Reaction(sMsg);
  840.  
  841.         ClearPointer(sWindow);
  842.         MyCloseWindow(sWindow);     { und Ende }
  843.         ActivateWindow(myWindow);
  844.       END;
  845.  
  846.     VAR MyNummer : SHORT;
  847.         MyBool   : BOOLEAN;
  848.  
  849.     BEGIN { Weiter mit ReactMSG-Main }
  850.       MyBool:=FALSE;
  851.       IF (MyMSG^.Class=Gadgetup_F) OR (MyMSG^.Class=GadgetDown_f) OR
  852.          (MyMSG^.Class=Rawkey_F)   THEN
  853.          BEGIN
  854.            IF MyMSG^.Class=RawKey_F THEN
  855.               BEGIN
  856.                 CASE MyMSG^.Code OF
  857.                   $43,
  858.                   $44,
  859.                   F1  : BEGIN
  860.                           MyNummer:=1;
  861.                           SelectGadget(MyRastPort,ADR(Gad01));
  862.                         END;
  863.                   F2  : BEGIN
  864.                           MyNummer:=2;
  865.                           SelectGadget(MyRastPort,ADR(Gad02));
  866.                         END;
  867.                   F3  : BEGIN
  868.                           MyNummer:=3;
  869.                           SelectGadget(MyRastPort,ADR(Gad03));
  870.                         END;
  871.                   F4  : BEGIN
  872.                           MyNummer:=4;
  873.                           SelectGadget(MyRastPort,ADR(Gad04));
  874.                         END;
  875.                   F5  : BEGIN
  876.                           MyNummer:=5;
  877.                           SelectGadget(MyRastPort,ADR(Gad05));
  878.                         END;
  879.                   F10 : BEGIN
  880.                           MyNummer:=10;
  881.                           SelectGadget(MyRastPort,ADR(Gad10));
  882.                         END;
  883.                   $21 : BEGIN
  884.                           IF MyModule<>NIL THEN
  885.                              BEGIN
  886.                                IF TBase^.Sound THEN BEGIN
  887.                                                       StopPlayer;
  888.                                                       TBase^.sound:=FALSE;
  889.                                                     END
  890.                                                ELSE BEGIN
  891.                                                       PlayModule(MyModule);
  892.                                                       TBase^.sound:=TRUE;
  893.                                                     END;
  894.                              END;
  895.                         END;
  896.                  ELSE;
  897.                 END;
  898.               END
  899.              ELSE MyNummer:=GetGadgetID(MyMSG^.IAddress);
  900.  
  901.            CASE MyNummer OF
  902.             1 : BEGIN
  903.                   Ende:=FALSE;    { Gadget 1 = Start }
  904.                   MyBool:=TRUE;
  905.                 END;
  906.             2 : Info;           { Gadget 2 }
  907.             3 : HighScore;      { ... }
  908.             4 : Options;
  909.             5 : Extra;
  910.            10 : BEGIN
  911.                   SetColours(FALSE);
  912.                   IF sprache=Deutsch THEN Ende:=Ask("Wirklich beenden???")   { Requester aufrufen }
  913.                                      ELSE Ende:=AskEnglish("Really quit???");
  914.  
  915.                   ResetColours(FALSE);
  916.                   MyBool:=Ende;
  917.                 END;
  918.            END;
  919.          END;
  920.  
  921.       ReactMSG:=MyBool;
  922.     END;
  923.  
  924.   VAR Start    : BOOLEAN;
  925.       MyIntMSG : IntuiMessagePtr;
  926.  
  927.   BEGIN { Init-Main }
  928.     Init_Base;
  929.  
  930.     Activatewindow(MyWindow);
  931.  
  932.     Ende:=FALSE;
  933.     REPEAT
  934.       KillMSGs(MyWindow^.UserPort);
  935.  
  936.       MyIntMSG:=ADDRESS(WaitPort(MyWindow^.UserPort));
  937.       MyIntMSG:=ADDRESS(GetMSG(MyWindow^.UserPort));
  938.       IF MyIntMSG<>NIL THEN BEGIN
  939.                               Start:=ReactMSG(MyIntMSG);
  940.                               ReplyMSG(ADDRESS(MyIntMSG));
  941.                             END;
  942.     UNTIL Start;
  943.  
  944.     DelMouse(MyWindow);
  945.  
  946.     IF TBase^.Use_Maze THEN SetLoadedPlayers;
  947.   END;
  948.  
  949. { Init Ende }
  950.  
  951. PROCEDURE Init1st; { Erstes Init - nur bei Neustart }
  952.  
  953.   VAR ShortHelp : SHORT;
  954.  
  955.   PROCEDURE Init_Control;
  956.  
  957.     { Spieler 1 und 2 brauchen keine Tasten, da Joysticks, werden hier aber}
  958.     {  trotzdem gesetzt...                                                 }
  959.  
  960.     PROCEDURE SetControl(aControl : ControlPtr;a,b,c : SHORT);
  961.  
  962.       BEGIN
  963.         WITH aControl^ DO
  964.           BEGIN
  965.             links:=a;
  966.             rechts:=b;
  967.             vorne:=c;
  968.           END;
  969.       END;
  970.  
  971.     BEGIN
  972.       WITH TBase^ DO
  973.         BEGIN
  974.           players[1].Steuerung:=Joy1;
  975.           players[2].Steuerung:=Joy2;
  976.           players[3].Steuerung:=Tasten;
  977.           players[4].Steuerung:=Tasten;
  978.           players[5].Steuerung:=Tasten;
  979.           players[6].Steuerung:=Tasten;
  980.  
  981.           SetControl(ADR(players[1].plcontrol), 50, 52,179);{ xvc          }
  982.           SetControl(ADR(players[2].plcontrol), 54, 56,183);{ n,m          }
  983.  
  984.           SetControl(ADR(players[3].plcontrol), 79, 78,204);{ Cursortasten }
  985.           SetControl(ADR(players[4].plcontrol),100,102, 96);{ links Alt,Shift,C=}
  986.           SetControl(ADR(players[5].plcontrol),103,101, 97);{ rechts Alt,Shift,Amiga }
  987.           SetControl(ADR(players[6].plControl), 67, 74,222);{ Enter,-,+    }
  988.         END;
  989.     END;
  990.  
  991.   PROCEDURE Init_Maze;
  992.  
  993.     VAR x : BYTE;
  994.  
  995.     BEGIN
  996.       WITH TBase^ DO
  997.         BEGIN
  998.           Maze_loaded:=FALSE;
  999.           Use_Maze:=FALSE;
  1000.           WITH MyMaze DO
  1001.             BEGIN
  1002.               StrCat(MyMaze.MazeDir,"Mazes");
  1003.               StrCpy(MyMaze.MazeName,"");
  1004.               FOR x:=1 TO maxplay DO
  1005.                 players[x].ist_geladen:=FALSE;
  1006.               Loeschen:=TRUE;
  1007.             END;
  1008.         END;
  1009.     END;
  1010.  
  1011.   BEGIN
  1012.     Selfseed;
  1013.  
  1014.     With TBase^ DO
  1015.       BEGIN
  1016.         FOR ShortHelp:=1 TO MaxPlay DO { Grundeinstellungen             }
  1017.           BEGIN                        { Eigenschaften wurden schon bei }
  1018.             WITH players[shorthelp] DO { Typendefinition erwähnt...     }
  1019.               BEGIN
  1020.                 ok:=TRUE;
  1021.                 Complayer:=(ShortHelp>human);
  1022.                 score:=0;
  1023.               END;
  1024.           END;
  1025.       END;
  1026.     Init_Control;
  1027.     Init_Maze;
  1028.     ScreenToFront(MyScreen);
  1029.  
  1030.     SetSColours;
  1031.     ViewMouse(MyWindow);
  1032.  
  1033.     Init;
  1034.   END;
  1035.